//
// CLandscapeGlobals.java
// Copyright (C) 2010  "Naush" <naush _ hotmail _ fr>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>./* ----------------------------------------------------------------------------







package org.ryzom.nel.threed;

import org.ryzom.nel.misc.CVector;

public class CLandscapeGlobals {
  private long swigCPtr;
  protected boolean swigCMemOwn;

  public CLandscapeGlobals(long cPtr, boolean cMemoryOwn) {
    swigCMemOwn = cMemoryOwn;
    swigCPtr = cPtr;
  }

  public static long getCPtr(CLandscapeGlobals obj) {
    return (obj == null) ? 0 : obj.swigCPtr;
  }

  protected void finalize() {
    delete();
  }

  public synchronized void delete() {
    if (swigCPtr != 0) {
      if (swigCMemOwn) {
        swigCMemOwn = false;
        nel3dJNI.delete_CLandscapeGlobals(swigCPtr);
      }
      swigCPtr = 0;
    }
  }

  public static void setCurrentDate(int value) {
    nel3dJNI.CLandscapeGlobals_CurrentDate_set(value);
  }

  public static int getCurrentDate() {
    return nel3dJNI.CLandscapeGlobals_CurrentDate_get();
  }

  public static void setCurrentRenderDate(int value) {
    nel3dJNI.CLandscapeGlobals_CurrentRenderDate_set(value);
  }

  public static int getCurrentRenderDate() {
    return nel3dJNI.CLandscapeGlobals_CurrentRenderDate_get();
  }

  public static void setRefineCenter(CVector value) {
    nel3dJNI.CLandscapeGlobals_RefineCenter_set(CVector.getCPtr(value), value);
  }

  public static CVector getRefineCenter() {
    long cPtr = nel3dJNI.CLandscapeGlobals_RefineCenter_get();
    return (cPtr == 0) ? null : new CVector(cPtr, false);
  }

  public static void setRefineThreshold(float value) {
    nel3dJNI.CLandscapeGlobals_RefineThreshold_set(value);
  }

  public static float getRefineThreshold() {
    return nel3dJNI.CLandscapeGlobals_RefineThreshold_get();
  }

  public static void setOORefineThreshold(float value) {
    nel3dJNI.CLandscapeGlobals_OORefineThreshold_set(value);
  }

  public static float getOORefineThreshold() {
    return nel3dJNI.CLandscapeGlobals_OORefineThreshold_get();
  }

  public static void setPZBModelPosition(CVector value) {
    nel3dJNI.CLandscapeGlobals_PZBModelPosition_set(CVector.getCPtr(value), value);
  }

  public static CVector getPZBModelPosition() {
    long cPtr = nel3dJNI.CLandscapeGlobals_PZBModelPosition_get();
    return (cPtr == 0) ? null : new CVector(cPtr, false);
  }

  public static void setTileDistNear(float value) {
    nel3dJNI.CLandscapeGlobals_TileDistNear_set(value);
  }

  public static float getTileDistNear() {
    return nel3dJNI.CLandscapeGlobals_TileDistNear_get();
  }

  public static void setTileDistFar(float value) {
    nel3dJNI.CLandscapeGlobals_TileDistFar_set(value);
  }

  public static float getTileDistFar() {
    return nel3dJNI.CLandscapeGlobals_TileDistFar_get();
  }

  public static void setTileDistNearSqr(float value) {
    nel3dJNI.CLandscapeGlobals_TileDistNearSqr_set(value);
  }

  public static float getTileDistNearSqr() {
    return nel3dJNI.CLandscapeGlobals_TileDistNearSqr_get();
  }

  public static void setTileDistFarSqr(float value) {
    nel3dJNI.CLandscapeGlobals_TileDistFarSqr_set(value);
  }

  public static float getTileDistFarSqr() {
    return nel3dJNI.CLandscapeGlobals_TileDistFarSqr_get();
  }

  public static void setOOTileDistDeltaSqr(float value) {
    nel3dJNI.CLandscapeGlobals_OOTileDistDeltaSqr_set(value);
  }

  public static float getOOTileDistDeltaSqr() {
    return nel3dJNI.CLandscapeGlobals_OOTileDistDeltaSqr_get();
  }

  public static void setTileMaxSubdivision(int value) {
    nel3dJNI.CLandscapeGlobals_TileMaxSubdivision_set(value);
  }

  public static int getTileMaxSubdivision() {
    return nel3dJNI.CLandscapeGlobals_TileMaxSubdivision_get();
  }

  public static void setTileFarSphere(SWIGTYPE_p_NLMISC__CBSphere value) {
    nel3dJNI.CLandscapeGlobals_TileFarSphere_set(SWIGTYPE_p_NLMISC__CBSphere.getCPtr(value));
  }

  public static SWIGTYPE_p_NLMISC__CBSphere getTileFarSphere() {
    return new SWIGTYPE_p_NLMISC__CBSphere(nel3dJNI.CLandscapeGlobals_TileFarSphere_get(), true);
  }

  public static void setTileNearSphere(SWIGTYPE_p_NLMISC__CBSphere value) {
    nel3dJNI.CLandscapeGlobals_TileNearSphere_set(SWIGTYPE_p_NLMISC__CBSphere.getCPtr(value));
  }

  public static SWIGTYPE_p_NLMISC__CBSphere getTileNearSphere() {
    return new SWIGTYPE_p_NLMISC__CBSphere(nel3dJNI.CLandscapeGlobals_TileNearSphere_get(), true);
  }

  public static void setTilePixelSize(float value) {
    nel3dJNI.CLandscapeGlobals_TilePixelSize_set(value);
  }

  public static float getTilePixelSize() {
    return nel3dJNI.CLandscapeGlobals_TilePixelSize_get();
  }

  public static void setTilePixelBias128(float value) {
    nel3dJNI.CLandscapeGlobals_TilePixelBias128_set(value);
  }

  public static float getTilePixelBias128() {
    return nel3dJNI.CLandscapeGlobals_TilePixelBias128_get();
  }

  public static void setTilePixelScale128(float value) {
    nel3dJNI.CLandscapeGlobals_TilePixelScale128_set(value);
  }

  public static float getTilePixelScale128() {
    return nel3dJNI.CLandscapeGlobals_TilePixelScale128_get();
  }

  public static void setTilePixelBias256(float value) {
    nel3dJNI.CLandscapeGlobals_TilePixelBias256_set(value);
  }

  public static float getTilePixelBias256() {
    return nel3dJNI.CLandscapeGlobals_TilePixelBias256_get();
  }

  public static void setTilePixelScale256(float value) {
    nel3dJNI.CLandscapeGlobals_TilePixelScale256_set(value);
  }

  public static float getTilePixelScale256() {
    return nel3dJNI.CLandscapeGlobals_TilePixelScale256_get();
  }

  public static void setFar0Dist(float value) {
    nel3dJNI.CLandscapeGlobals_Far0Dist_set(value);
  }

  public static float getFar0Dist() {
    return nel3dJNI.CLandscapeGlobals_Far0Dist_get();
  }

  public static void setFar1Dist(float value) {
    nel3dJNI.CLandscapeGlobals_Far1Dist_set(value);
  }

  public static float getFar1Dist() {
    return nel3dJNI.CLandscapeGlobals_Far1Dist_get();
  }

  public static void setFarTransition(float value) {
    nel3dJNI.CLandscapeGlobals_FarTransition_set(value);
  }

  public static float getFarTransition() {
    return nel3dJNI.CLandscapeGlobals_FarTransition_get();
  }

  public static void setVertexProgramEnabled(boolean value) {
    nel3dJNI.CLandscapeGlobals_VertexProgramEnabled_set(value);
  }

  public static boolean getVertexProgramEnabled() {
    return nel3dJNI.CLandscapeGlobals_VertexProgramEnabled_get();
  }

  public static void setCurrentFar0VBInfo(CFarVertexBufferInfo value) {
    nel3dJNI.CLandscapeGlobals_CurrentFar0VBInfo_set(CFarVertexBufferInfo.getCPtr(value), value);
  }

  public static CFarVertexBufferInfo getCurrentFar0VBInfo() {
    return new CFarVertexBufferInfo(nel3dJNI.CLandscapeGlobals_CurrentFar0VBInfo_get(), true);
  }

  public static void setCurrentFar1VBInfo(CFarVertexBufferInfo value) {
    nel3dJNI.CLandscapeGlobals_CurrentFar1VBInfo_set(CFarVertexBufferInfo.getCPtr(value), value);
  }

  public static CFarVertexBufferInfo getCurrentFar1VBInfo() {
    return new CFarVertexBufferInfo(nel3dJNI.CLandscapeGlobals_CurrentFar1VBInfo_get(), true);
  }

  public static void setCurrentTileVBInfo(CNearVertexBufferInfo value) {
    nel3dJNI.CLandscapeGlobals_CurrentTileVBInfo_set(CNearVertexBufferInfo.getCPtr(value), value);
  }

  public static CNearVertexBufferInfo getCurrentTileVBInfo() {
    return new CNearVertexBufferInfo(nel3dJNI.CLandscapeGlobals_CurrentTileVBInfo_get(), true);
  }

  public static void setCurrentFar0VBAllocator(CLandscapeVBAllocator value) {
    nel3dJNI.CLandscapeGlobals_CurrentFar0VBAllocator_set(CLandscapeVBAllocator.getCPtr(value), value);
  }

  public static CLandscapeVBAllocator getCurrentFar0VBAllocator() {
    long cPtr = nel3dJNI.CLandscapeGlobals_CurrentFar0VBAllocator_get();
    return (cPtr == 0) ? null : new CLandscapeVBAllocator(cPtr, false);
  }

  public static void setCurrentFar1VBAllocator(CLandscapeVBAllocator value) {
    nel3dJNI.CLandscapeGlobals_CurrentFar1VBAllocator_set(CLandscapeVBAllocator.getCPtr(value), value);
  }

  public static CLandscapeVBAllocator getCurrentFar1VBAllocator() {
    long cPtr = nel3dJNI.CLandscapeGlobals_CurrentFar1VBAllocator_get();
    return (cPtr == 0) ? null : new CLandscapeVBAllocator(cPtr, false);
  }

  public static void setCurrentTileVBAllocator(CLandscapeVBAllocator value) {
    nel3dJNI.CLandscapeGlobals_CurrentTileVBAllocator_set(CLandscapeVBAllocator.getCPtr(value), value);
  }

  public static CLandscapeVBAllocator getCurrentTileVBAllocator() {
    long cPtr = nel3dJNI.CLandscapeGlobals_CurrentTileVBAllocator_get();
    return (cPtr == 0) ? null : new CLandscapeVBAllocator(cPtr, false);
  }

  public static void setPatchCurrentDriver(IDriver value) {
    nel3dJNI.CLandscapeGlobals_PatchCurrentDriver_set(IDriver.getCPtr(value), value);
  }

  public static IDriver getPatchCurrentDriver() {
    long cPtr = nel3dJNI.CLandscapeGlobals_PatchCurrentDriver_get();
    return (cPtr == 0) ? null : new IDriver(cPtr, false);
  }

  public static void setPassTriArray(CIndexBuffer value) {
    nel3dJNI.CLandscapeGlobals_PassTriArray_set(CIndexBuffer.getCPtr(value), value);
  }

  public static CIndexBuffer getPassTriArray() {
    long cPtr = nel3dJNI.CLandscapeGlobals_PassTriArray_get();
    return (cPtr == 0) ? null : new CIndexBuffer(cPtr, false);
  }

  public static CIndexBufferReadWrite getPassTriArrayIBA() {
    long cPtr = nel3dJNI.CLandscapeGlobals_PassTriArrayIBA_get();
    return (cPtr == 0) ? null : new CIndexBufferReadWrite(cPtr, false);
  }

  public CLandscapeGlobals() {
    this(nel3dJNI.new_CLandscapeGlobals(), true);
  }

}
